#include<stdio.h>

int main() {
	int a[4] = { 1, 2, 3, 4 };
	//&a 代表整个数组地址 + 1 加到整个数组最后一个元素的下一个元素位置
	//强转为int* ++ 和 -- 变为+int类型大小
	//ptr[-1] 就是访问 *(ptr - 1) 位置元素 由于当前ptr指向数组最后一个元素的下一个元素位置
	//-1也就是减去类型大小int 就到了数组最后一个元素位置 解引用 就是以16进制打印数组最后一个元素
	//0x4

	int* ptr1 = (int*)(&a + 1);

	//a单独出现 代表数组首元素地址 也就是&a[0] 强转为int 再加一 说明给ptr2的指针加1个字节
	//a数组在内存中的存储本来为
	//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 (小端存储)
	//此时地址加一个字节 ptr2指向了下一个字节
	//此时ptr指向的内容在内存中的存储为
	//00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 ??
	//此时再对ptr2解引用 ptr类型为int* 解引用访问一个int类型 
	//此时访问的数据为 00 00 00 02(小端存储)
	//用16进制打印为
	// 02000000


	//x64环境下a 地址假设为		0x0000002bef1bf678
	//转为int类型 + 1
	//前八位被截断 变为			0xef1bf679
	//再次强转为int*类型 变为	    发生整形提升 int类型补符号位，符号位为1
	// 所以变成					0xffffffffef1bf679
	//此时这个地址就是未知，不能访问

	int* ptr2 = (int*)((int)a + 1);

	printf("%x,%x", ptr1[-1], *ptr2);
	return 0;
}


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeElements(struct ListNode* head, int val) {
	struct ListNode* cur = head;
	struct ListNode* pre = NULL;
	while (cur) {
		if (cur->val == val) {
			//head是要删除节点
			if (pre == NULL) {
				struct ListNode* Next = cur->next;
				free(cur);
				cur = Next;
				head = cur;
			}
			else {
				pre->next = cur->next;
				free(cur);
				cur = pre->next;
			}


		}
		else {
			pre = cur;
			cur = cur->next;
		}
	}
	return head;
}

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeElements(struct ListNode* head, int val) {
	struct ListNode* newHead = (struct ListNode*)malloc(sizeof(struct ListNode));
	newHead->next = head;
	struct ListNode* prev = newHead;

	while (prev->next) {
		if (prev->next->val == val) {
			prev->next = prev->next->next;
		}
		else {
			prev = prev->next;
		}
	}

	return newHead->next;
}


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* middleNode(struct ListNode* head) {
	//头结点为空或者只有一个节点
	if (head == NULL || head->next == NULL) return head;

	//快慢指针,慢指针走一步,快指针走两步,快指针为空时,慢指针就是链表的中间结点

	struct ListNode* fast = head;
	struct ListNode* slow = head;

	//快指针要走两步,如果fast走到最后一个节点,那么就不能再走两步
	while (fast && fast->next) {
		fast = fast->next->next;
		slow = slow->next;
	}
	return slow;

}/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* getIntersectionNode(struct ListNode* headA, struct ListNode* headB) {
	//计算两个链表之间的差

	int countA = 0;
	int countB = 0;
	struct ListNode* cur = headA;
	while (cur) {
		cur = cur->next;
		countA++;
	}
	cur = headB;
	while (cur) {
		cur = cur->next;
		countB++;
	}

	if (countA > countB) {
		int count = countA - countB;
		while (count--) {
			headA = headA->next;
		}
	}
	else {
		int count = countB - countA;
		while (count--) {
			headB = headB->next;
		}
	}

	while (headA && headB) {
		if (headA == headB) {
			return headA;
		}
		else {
			headA = headA->next;
			headB = headB->next;
		}
	}
	return NULL;
}
